/**
 * 抽奖缓存管理工具
 * 用于管理每日一次和每周一次的抽奖限制
 * 
 * 使用示例：
 * 
 * 1. 检查今日是否已抽奖（每日一次）：
 *    import { lotteryCache } from '@/api'
 *    if (!lotteryCache.checkDailyLottery('donation_3000')) {
 *      // 可以抽奖
 *      lotteryCache.markDailyLottery('donation_3000')
 *    }
 * 
 * 2. 检查本周是否已抽奖（每周一次）：
 *    if (!lotteryCache.checkWeeklyLottery('donation_7days')) {
 *      // 可以抽奖
 *      lotteryCache.markWeeklyLottery('donation_7days')
 *    }
 * 
 * 3. 抽奖类型常量：
 *    - 每日抽奖：
 *      * 'donation_3000' - 个人捐步≥3000步（周卡抽奖）
 *      * 'donation_8000' - 个人捐步≥8000步（月卡抽奖）
 *      * 'store_checkin' - 门店打卡抽奖
 *      * 'music_share' - 行走的歌单抽奖
 *    - 每周抽奖：
 *      * 'donation_7days' - 个人完成7天捐步（50元京东E卡）
 *      * 'team_50000' - 团队步数达到5万步（季卡抽奖）
 *      * 'team_success' - 组队成功抽奖
 */

// 缓存键前缀
const DAILY_PREFIX = 'lottery_daily_'
const WEEKLY_PREFIX = 'lottery_weekly_'

/**
 * 抽奖类型常量
 */
export const LotteryType = {
  // 每日抽奖类型
  DAILY: {
    DONATION_3000: 'donation_3000', // 个人捐步≥3000步（周卡抽奖）
    DONATION_8000: 'donation_8000', // 个人捐步≥8000步（月卡抽奖）
    STORE_CHECKIN: 'store_checkin', // 门店打卡抽奖
    MUSIC_SHARE: 'music_share' // 行走的歌单抽奖
  },
  // 每周抽奖类型
  WEEKLY: {
    DONATION_7DAYS: 'donation_7days', // 个人完成7天捐步（50元京东E卡）
    TEAM_50000: 'team_50000', // 团队步数达到5万步（季卡抽奖）
    TEAM_SUCCESS: 'team_success' // 组队成功抽奖
  }
} as const

/**
 * 获取今日日期字符串（YYYY-MM-DD）
 */
function getTodayDate(): string {
  const now = new Date()
  const year = now.getFullYear()
  const month = String(now.getMonth() + 1).padStart(2, '0')
  const day = String(now.getDate()).padStart(2, '0')
  return `${year}-${month}-${day}`
}

/**
 * 获取本周开始日期（周一）字符串（YYYY-MM-DD）
 */
function getWeekStartDate(): string {
  const now = new Date()
  const day = now.getDay() // 0=周日, 1=周一, ..., 6=周六
  // 计算距离周一的天数（如果今天是周日，则距离周一6天；否则距离周一 day-1 天）
  const daysToMonday = day === 0 ? 6 : day - 1
  const monday = new Date(now)
  monday.setDate(now.getDate() - daysToMonday)
  monday.setHours(0, 0, 0, 0)
  
  const year = monday.getFullYear()
  const month = String(monday.getMonth() + 1).padStart(2, '0')
  const dayOfMonth = String(monday.getDate()).padStart(2, '0')
  return `${year}-${month}-${dayOfMonth}`
}

/**
 * 生成每日抽奖缓存键
 */
function getDailyCacheKey(type: string, date?: string): string {
  const targetDate = date || getTodayDate()
  return `${DAILY_PREFIX}${type}_${targetDate}`
}

/**
 * 生成每周抽奖缓存键
 */
function getWeeklyCacheKey(type: string, weekStartDate?: string): string {
  const targetWeekStart = weekStartDate || getWeekStartDate()
  return `${WEEKLY_PREFIX}${type}_${targetWeekStart}`
}

/**
 * 检查今日是否已抽奖（每日一次）
 * @param type 抽奖类型
 * @returns true 表示今日已抽奖，false 表示今日未抽奖
 */
function checkDailyLottery(type: string): boolean {
  try {
    const cacheKey = getDailyCacheKey(type)
    const cached = uni.getStorageSync(cacheKey)
    return cached === true || cached === 'true'
  } catch (error) {
    console.warn('检查每日抽奖缓存失败:', error)
    return false
  }
}

/**
 * 标记今日已抽奖（每日一次）
 * @param type 抽奖类型
 */
function markDailyLottery(type: string): void {
  try {
    const cacheKey = getDailyCacheKey(type)
    uni.setStorageSync(cacheKey, true)
    console.log(`已标记每日抽奖: ${type} (${getTodayDate()})`)
  } catch (error) {
    console.warn('标记每日抽奖失败:', error)
  }
}

/**
 * 检查本周是否已抽奖（每周一次）
 * @param type 抽奖类型
 * @returns true 表示本周已抽奖，false 表示本周未抽奖
 */
function checkWeeklyLottery(type: string): boolean {
  try {
    const cacheKey = getWeeklyCacheKey(type)
    const cached = uni.getStorageSync(cacheKey)
    return cached === true || cached === 'true'
  } catch (error) {
    console.warn('检查每周抽奖缓存失败:', error)
    return false
  }
}

/**
 * 标记本周已抽奖（每周一次）
 * @param type 抽奖类型
 */
function markWeeklyLottery(type: string): void {
  try {
    const cacheKey = getWeeklyCacheKey(type)
    uni.setStorageSync(cacheKey, true)
    console.log(`已标记每周抽奖: ${type} (${getWeekStartDate()})`)
  } catch (error) {
    console.warn('标记每周抽奖失败:', error)
  }
}

/**
 * 清除今日的抽奖标记（用于测试或重置）
 * @param type 抽奖类型，如果不传则清除所有今日的抽奖标记
 */
function clearDailyLottery(type?: string): void {
  try {
    if (type) {
      const cacheKey = getDailyCacheKey(type)
      uni.removeStorageSync(cacheKey)
      console.log(`已清除每日抽奖标记: ${type}`)
    } else {
      // 清除所有今日的每日抽奖标记
      const today = getTodayDate()
      const keys = [
        getDailyCacheKey(LotteryType.DAILY.DONATION_3000, today),
        getDailyCacheKey(LotteryType.DAILY.DONATION_8000, today),
        getDailyCacheKey(LotteryType.DAILY.STORE_CHECKIN, today),
        getDailyCacheKey(LotteryType.DAILY.MUSIC_SHARE, today)
      ]
      keys.forEach(key => {
        try {
          uni.removeStorageSync(key)
        } catch (e) {
          // 忽略不存在的键
        }
      })
      console.log('已清除所有今日的每日抽奖标记')
    }
  } catch (error) {
    console.warn('清除每日抽奖标记失败:', error)
  }
}

/**
 * 清除本周的抽奖标记（用于测试或重置）
 * @param type 抽奖类型，如果不传则清除所有本周的抽奖标记
 */
function clearWeeklyLottery(type?: string): void {
  try {
    if (type) {
      const cacheKey = getWeeklyCacheKey(type)
      uni.removeStorageSync(cacheKey)
      console.log(`已清除每周抽奖标记: ${type}`)
    } else {
      // 清除所有本周的每周抽奖标记
      const weekStart = getWeekStartDate()
      const keys = [
        getWeeklyCacheKey(LotteryType.WEEKLY.DONATION_7DAYS, weekStart),
        getWeeklyCacheKey(LotteryType.WEEKLY.TEAM_50000, weekStart),
        getWeeklyCacheKey(LotteryType.WEEKLY.TEAM_SUCCESS, weekStart)
      ]
      keys.forEach(key => {
        try {
          uni.removeStorageSync(key)
        } catch (e) {
          // 忽略不存在的键
        }
      })
      console.log('已清除所有本周的每周抽奖标记')
    }
  } catch (error) {
    console.warn('清除每周抽奖标记失败:', error)
  }
}

/**
 * 清除所有过期的抽奖缓存（清理旧日期的缓存）
 * 注意：此方法会遍历所有存储的键，可能影响性能，建议在合适的时机调用
 */
function clearExpiredCache(): void {
  try {
    const today = getTodayDate()
    const weekStart = getWeekStartDate()
    
    // 获取所有存储的键（注意：uni.getStorageInfoSync 可能在某些平台不支持）
    // 这里采用保守策略，只清理已知的过期键
    const todayDate = new Date(today)
    const weekStartDate = new Date(weekStart)
    
    // 清理30天前的每日抽奖缓存（保留最近30天）
    for (let i = 1; i <= 30; i++) {
      const pastDate = new Date(todayDate)
      pastDate.setDate(todayDate.getDate() - i)
      const pastDateStr = `${pastDate.getFullYear()}-${String(pastDate.getMonth() + 1).padStart(2, '0')}-${String(pastDate.getDate()).padStart(2, '0')}`
      
      // 清理所有类型的每日抽奖缓存
      Object.values(LotteryType.DAILY).forEach(type => {
        const key = getDailyCacheKey(type, pastDateStr)
        try {
          uni.removeStorageSync(key)
        } catch (e) {
          // 忽略不存在的键
        }
      })
    }
    
    // 清理4周前的每周抽奖缓存（保留最近4周）
    for (let i = 1; i <= 4; i++) {
      const pastWeekStart = new Date(weekStartDate)
      pastWeekStart.setDate(weekStartDate.getDate() - i * 7)
      const pastWeekStartStr = `${pastWeekStart.getFullYear()}-${String(pastWeekStart.getMonth() + 1).padStart(2, '0')}-${String(pastWeekStart.getDate()).padStart(2, '0')}`
      
      // 清理所有类型的每周抽奖缓存
      Object.values(LotteryType.WEEKLY).forEach(type => {
        const key = getWeeklyCacheKey(type, pastWeekStartStr)
        try {
          uni.removeStorageSync(key)
        } catch (e) {
          // 忽略不存在的键
        }
      })
    }
    
    console.log('已清理过期抽奖缓存')
  } catch (error) {
    console.warn('清理过期缓存失败:', error)
  }
}

/**
 * 获取今日日期（用于调试）
 */
function getTodayDateString(): string {
  return getTodayDate()
}

/**
 * 获取本周开始日期（用于调试）
 */
function getWeekStartDateString(): string {
  return getWeekStartDate()
}

export const lotteryCache = {
  // 抽奖类型常量
  LotteryType,
  
  // 每日抽奖方法
  checkDailyLottery,
  markDailyLottery,
  clearDailyLottery,
  
  // 每周抽奖方法
  checkWeeklyLottery,
  markWeeklyLottery,
  clearWeeklyLottery,
  
  // 工具方法
  clearExpiredCache,
  getTodayDateString,
  getWeekStartDateString
}

